篇首语：本文由编程笔记#小编为大家整理，主要介绍了C语言基本数据类型有哪些？相关的知识，希望对你有一定的参考价值。
本节将详细介绍C语言的基本数据类型&＃xff0c;包括如何声明变量、如何表示字面值常量&＃xff08;如&＃xff0c;5或2.78&＃xff09;&＃xff0c;以及典型的用法。一些老式的C语言编译器无法支持这里提到的所有类型&＃xff0c;请查阅你使用的编译器文档&＃xff0c;了解可以使用哪些类型。
C语言提供了许多整数类型&＃xff0c;为什么一种类型不够用&＃xff1f;因为C语言让程序员针对不同情况选择不同的类型。特别是&＃xff0c;C语言中的整数类型可表示不同的取值范围和正负值。一般情况使用int类型即可&＃xff0c;但是为满足特定任务和机器的要求&＃xff0c;还可以选择其他类型。
int类型是有符号整型&＃xff0c;即int类型的值必须是整数&＃xff0c;可以是正整数、负整数或零。其取值范围依计算机系统而异。一般而言&＃xff0c;储存一个int要占用一个机器字长。因此&＃xff0c;早期的16位IBM PC兼容机使用16位来储存一个int值&＃xff0c;其取值范围&＃xff08;即int值的取值范围&＃xff09;是-32768&＃xff5e;32767。目前的个人计算机一般是32位&＃xff0c;因此用32位储存一个int值。现在&＃xff0c;个人计算机产业正逐步向着64位处理器发展&＃xff0c;自然能储存更大的整数。ISO C规定int的取值范围最小为-32768&＃xff5e;32767。一般而言&＃xff0c;系统用一个特殊位的值表示有符号整数的正负号。第15章将介绍常用的方法。
第2章中已经用int声明过基本整型变量。先写上int&＃xff0c;然后写变量名&＃xff0c;最后加上一个分号。要声明多个变量&＃xff0c;可以单独声明每个变量&＃xff0c;也可在int后面列出多个变量名&＃xff0c;变量名之间用逗号分隔。下面都是有效的声明&＃xff1a;
int erns;
int hogs, cows, goats;
可以分别在4条声明中声明各变量&＃xff0c;也可以在一条声明中声明4个变量。两种方法的效果相同&＃xff0c;都为4个int大小的变量赋予名称并分配内存空间。
以上声明创建了变量&＃xff0c;但是并没有给它们提供值。变量如何获得值&＃xff1f;前面介绍过在程序中获取值的两种途径。第1种途径是赋值&＃xff1a;
cows &＃61; 112;
第2种途径是&＃xff0c;通过函数&＃xff08;如&＃xff0c;scanf()&＃xff09;获得值。接下来&＃xff0c;我们着重介绍第3种途径。
初始化&＃xff08;initialize&＃xff09;变量就是为变量赋一个初始值。在C语言中&＃xff0c;初始化可以直接在声明中完成。只需在变量名后面加上赋值运算符&＃xff08;&＃61;&＃xff09;和待赋给变量的值即可。如下所示&＃xff1a;
int hogs &＃61; 21;
int cows &＃61; 32, goats &＃61; 14;
int dogs, cats &＃61; 94; /* 有效&＃xff0c;但是这种格式很糟糕 */
以上示例的最后一行&＃xff0c;只初始化了cats&＃xff0c;并未初始化dogs。这种写法很容易让人误认为dogs也被初始化为94&＃xff0c;所以最好不要把初始化的变量和未初始化的变量放在同一条声明中。
简而言之&＃xff0c;声明为变量创建和标记存储空间&＃xff0c;并为其指定初始值&＃xff08;如图3.4所示&＃xff09;。
图3.4 定义并初始化变量
上面示例中出现的整数&＃xff08;21、32、14和94&＃xff09;都是整型常量或整型字面量。C语言把不含小数点和指数的数作为整数。因此&＃xff0c;22和-44都是整型常量&＃xff0c;但是22.0和2.2E1则不是。C语言把大多数整型常量视为int类型&＃xff0c;但是非常大的整数除外。详见后面“long常量和long long常量”小节对long int类型的讨论。
可以使用printf()函数打印int类型的值。第2章中介绍过&＃xff0c;%d指明了在一行中打印整数的位置。%d称为转换说明&＃xff0c;它指定了printf()应使用什么格式来显示一个值。格式化字符串中的每个%d都与待打印变量列表中相应的int值匹配。这个值可以是int类型的变量、int类型的常量或其他任何值为int类型的表达式。作为程序员&＃xff0c;要确保转换说明的数量与待打印值的数量相同&＃xff0c;编译器不会捕获这类型的错误。程序清单3.2演示了一个简单的程序&＃xff0c;程序中初始化了一个变量&＃xff0c;并打印该变量的值、一个常量值和一个简单表达式的值。另外&＃xff0c;程序还演示了如果粗心犯错会导致什么结果。
程序清单3.2 print1.c程序
/* print1.c - 演示printf()的一些特性 */
#include
int main(void)
int ten &＃61; 10;
int two &＃61; 2;
printf("Doing it right: ");
printf("%d minus %d is %d\\n", ten, 2, ten - two);
printf("Doing it wrong: ");
printf("%d minus %d is %d\\n", ten); // 遗漏2个参数
return 0;
编译并运行该程序&＃xff0c;输出如下&＃xff1a;
Doing it right: 10 minus 2 is 8
Doing it wrong: 10 minus 16 is 1650287143
在第一行输出中&＃xff0c;第1个%d对应int类型变量ten&＃xff1b;第2个%d对应int类型常量2&＃xff1b;第3个%d对应int类型表达式ten - two的值。在第二行输出中&＃xff0c;第1个%d对应ten的值&＃xff0c;但是由于没有给后两个%d提供任何值&＃xff0c;所以打印出的值是内存中的任意值&＃xff08;读者在运行该程序时显示的这两个数值会与输出示例中的数值不同&＃xff0c;因为内存中储存的数据不同&＃xff0c;而且编译器管理内存的位置也不同&＃xff09;。
你可能会抱怨编译器为何不能捕获这种明显的错误&＃xff0c;但实际上问题出在printf()不寻常的设计。大部分函数都需要指定数目的参数&＃xff0c;编译器会检查参数的数目是否正确。但是&＃xff0c;printf()函数的参数数目不定&＃xff0c;可以有1个、2个、3个或更多&＃xff0c;编译器也爱莫能助。记住&＃xff0c;使用printf()函数时&＃xff0c;要确保转换说明的数量与待打印值的数量相等。
通常&＃xff0c;C语言都假定整型常量是十进制数。然而&＃xff0c;许多程序员很喜欢使用八进制和十六进制数。因为8和16都是2的幂&＃xff0c;而10却不是。显然&＃xff0c;八进制和十六进制记数系统在表达与计算机相关的值时很方便。例如&＃xff0c;十进制数65536经常出现在16位机中&＃xff0c;用十六进制表示正好是10000。另外&＃xff0c;十六进制数的每一位的数恰好由4位二进制数表示。例如&＃xff0c;十六进制数3的二进制数是0011&＃xff0c;十六进制数5是的二进制数0101。因此&＃xff0c;十六进制数35的位组合&＃xff08;bit pattern&＃xff09;是00110101&＃xff0c;十六进制数53的位组合是01010011。这种对应关系使得十六进制和二进制的转换非常方便。但是&＃xff0c;计算机如何知道10000是十进制、十六进制还是二进制&＃xff1f;在C语言中&＃xff0c;用特定的前缀表示使用哪种进制。0x或0X前缀表示十六进制值&＃xff0c;所以十进制数16表示成十六进制是0x10或0X10。与此类似&＃xff0c;0前缀表示八进制。例如&＃xff0c;十进制数16表示成八进制是020。第15章将更全面地介绍进制相关的内容。
要清楚&＃xff0c;使用不同的进制数是为了方便&＃xff0c;不会影响数被储存的方式。也就是说&＃xff0c;无论把数字写成16、020或0x10&＃xff0c;储存该数的方式都相同&＃xff0c;因为计算机内部都以二进制进行编码。
在C程序中&＃xff0c;既可以使用也可以显示不同进制的数。不同的进制要使用不同的转换说明。以十进制显示数字&＃xff0c;使用%d&＃xff1b;以八进制显示数字&＃xff0c;使用%o&＃xff1b;以十六进制显示数字&＃xff0c;使用%x。另外&＃xff0c;要显示各进制数的前缀0、0x和0X&＃xff0c;必须分别使用%#o、%#x、%#X。程序清单3.3演示了一个小程序&＃xff08;回忆一下&＃xff0c;在某些集成开发环境&＃xff08;IDE&＃xff09;下编写的代码中插入getchar();语句&＃xff0c;程序在执行完毕后不会立即关闭执行窗口&＃xff09;。
程序清单3.3 bases.c程序
/* bases.c--以十进制、八进制、十六进制打印十进制数100 */
#include
int main(void)
int x &＃61; 100;
printf("dec &＃61; %d; octal &＃61; %o; hex &＃61; %x\\n", x, x, x);
printf("dec &＃61; %d; octal &＃61; %#o; hex &＃61; %#x\\n", x, x, x);
return 0;
编译并运行该程序&＃xff0c;输出如下&＃xff1a;
dec &＃61; 100; octal &＃61; 144; hex &＃61; 64
dec &＃61; 100; octal &＃61; 0144; hex &＃61; 0x64
该程序以3种不同记数系统显示同一个值。printf()函数做了相应的转换。注意&＃xff0c;如果要在八进制和十六进制值前显示0和0x前缀&＃xff0c;要分别在转换说明中加入#。
初学C语言时&＃xff0c;int类型应该能满足大多数程序的整数类型需求。尽管如此&＃xff0c;还应了解一下整型的其他形式。当然&＃xff0c;也可以略过本节跳至3.4.3节阅读char类型的相关内容&＃xff0c;以后有需要时再阅读本节。
C语言提供3个附属关键字修饰基本整数类型&＃xff1a;short、long和unsigned。应记住以下几点。
其他整数类型的声明方式与int类型相同&＃xff0c;下面列出了一些例子。不是所有的C编译器都能识别最后3条声明&＃xff0c;最后一个例子所有的类型是C99标准新增的。
long int estine;
long johns;
short int erns;
short ribs;
unsigned int s_count;
unsigned players;
unsigned long headcount;
unsigned short yesvotes;
long long ago;
2&＃xff0e;使用多种整数类型的原因
为什么说short类型“可能”比int类型占用的空间少&＃xff0c;long类型“可能”比int类型占用的空间多&＃xff1f;因为C语言只规定了short占用的存储空间不能多于int&＃xff0c;long占用的存储空间不能少于int。这样规定是为了适应不同的机器。例如&＃xff0c;过去的一台运行Windows 3.x的机器上&＃xff0c;int类型和short类型都占16位&＃xff0c;long类型占32位。后来&＃xff0c;Windows和苹果系统都使用16位储存short类型&＃xff0c;32位储存int类型和long类型&＃xff08;使用32位可以表示的整数数值超过20亿&＃xff09;。现在&＃xff0c;计算机普遍使用64位处理器&＃xff0c;为了储存64位的整数&＃xff0c;才引入了long long类型。
现在&＃xff0c;个人计算机上最常见的设置是&＃xff0c;long long占64位&＃xff0c;long占32位&＃xff0c;short占16位&＃xff0c;int占16位或32位&＃xff08;依计算机的自然字长而定&＃xff09;。原则上&＃xff0c;这4种类型代表4种不同的大小&＃xff0c;但是在实际使用中&＃xff0c;有些类型之间通常有重叠。
C标准对基本数据类型只规定了允许的最小大小。对于16位机&＃xff0c;short和int的最小取值范围是[−32767,32767]&＃xff1b;对于32位机&＃xff0c;long的最小取值范围是[−2147483647,2147483647]。对于unsigned short和unsigned int&＃xff0c;最小取值范围是[0,65535]&＃xff1b;对于unsigned long&＃xff0c;最小取值范围是[0,4294967295]。long long类型是为了支持64位的需求&＃xff0c;最小取值范围是[−9223372036854775807,9223372036854775807]&＃xff1b;unsigned long long的最小取值范围是[0,18446744073709551615]。如果要开支票&＃xff0c;这个数是一千八百亿亿六千七百四十四万亿零七百三十七亿零九百五十五万一千六百一十五。但是&＃xff0c;谁会去数&＃xff1f;
int类型那么多&＃xff0c;应该如何选择&＃xff1f;首先&＃xff0c;考虑unsigned类型。这种类型的数常用于计数&＃xff0c;因为计数不用负数。而且&＃xff0c;unsigned类型可以表示更大的正数。
如果一个数超出了int类型的取值范围&＃xff0c;且在long类型的取值范围内时&＃xff0c;使用long类型。然而&＃xff0c;对于那些long占用的空间比int大的系统&＃xff0c;使用long类型会减慢运算速度。因此&＃xff0c;如非必要&＃xff0c;请不要使用long类型。另外要注意一点&＃xff1a;如果在long类型和int类型占用空间相同的机器上编写代码&＃xff0c;当确实需要32位的整数时&＃xff0c;应使用long类型而不是int类型&＃xff0c;以便把程序移植到16位机后仍然可以正常工作。类似地&＃xff0c;如果确实需要64位的整数&＃xff0c;应使用long long类型。
如果在int设置为32位的系统中要使用16位的值&＃xff0c;应使用short类型以节省存储空间。通常&＃xff0c;只有当程序使用相对于系统可用内存较大的整型数组时&＃xff0c;才需要重点考虑节省空间的问题。使用short类型的另一个原因是&＃xff0c;计算机中某些组件使用的硬件寄存器是16位。
通常&＃xff0c;程序代码中使用的数字&＃xff08;如&＃xff0c;2345&＃xff09;都被储存为int类型。如果使用1000000这样的大数字&＃xff0c;超出了int类型能表示的范围&＃xff0c;编译器会将其视为long int类型&＃xff08;假设这种类型可以表示该数字&＃xff09;。如果数字超出long可表示的最大值&＃xff0c;编译器则将其视为unsigned long类型。如果还不够大&＃xff0c;编译器则将其视为long long或unsigned long long类型&＃xff08;前提是编译器能识别这些类型&＃xff09;。
八进制和十六进制常量被视为int类型。如果值太大&＃xff0c;编译器会尝试使用unsigned int。如果还不够大&＃xff0c;编译器会依次使用long、unsigned long、long long和unsigned long long类型。
有些情况下&＃xff0c;需要编译器以long类型储存一个小数字。例如&＃xff0c;编程时要显式使用IBM PC上的内存地址时。另外&＃xff0c;一些C标准函数也要求使用long类型的值。要把一个较小的常量作为long类型对待&＃xff0c;可以在值的末尾加上l&＃xff08;小写的L&＃xff09;或L后缀。使用L后缀更好&＃xff0c;因为l看上去和数字1很像。因此&＃xff0c;在int为16位、long为32位的系统中&＃xff0c;会把7作为16位储存&＃xff0c;把7L作为32位储存。l或L后缀也可用于八进制和十六进制整数&＃xff0c;如020L和0x10L。
类似地&＃xff0c;在支持long long类型的系统中&＃xff0c;也可以使用ll或LL后缀来表示long long类型的值&＃xff0c;如3LL。另外&＃xff0c;u或U后缀表示unsigned long long&＃xff0c;如5ull、10LLU、6LLU或9Ull。
整数溢出
如果整数超出了相应类型的取值范围会怎样&＃xff1f;下面分别将有符号类型和无符号类型的整数设置为比最大值略大&＃xff0c;看看会发生什么&＃xff08;printf()函数使用%u说明显示unsigned int类型的值&＃xff09;。
/* toobig.c-- 超出系统允许的最大int值*/ #include
int main(void) int i &＃61; 2147483647; unsigned int j &＃61; 4294967295; printf("%d %d %d\\n", i, i&＃43;1, i&＃43;2); printf("%u %u %u\\n", j, j&＃43;1, j&＃43;2); return 0;
在我们的系统下输出的结果是&＃xff1a;
2147483647 -2147483648 -2147483647 4294967295 0 1
可以把无符号整数j看作是汽车的里程表。当达到它能表示的最大值时&＃xff0c;会重新从起始点开始。整数i也是类似的情况。它们主要的区别是&＃xff0c;在超过最大值时&＃xff0c;unsigned int类型的变量j从0开始&＃xff1b;而int类型的变量i则从−2147483648开始。注意&＃xff0c;当i超出&＃xff08;溢出&＃xff09;其相应类型所能表示的最大值时&＃xff0c;系统并未通知用户。因此&＃xff0c;在编程时必须自己注意这类问题。
溢出行为是未定义的行为&＃xff0c;C标准并未定义有符号类型的溢出规则。以上描述的溢出行为比较有代表性&＃xff0c;但是也可能会出现其他情况。
打印unsigned int类型的值&＃xff0c;使用%u转换说明&＃xff1b;打印long类型的值&＃xff0c;使用%ld转换说明。如果系统中int和long的大小相同&＃xff0c;使用%d就行。但是&＃xff0c;这样的程序被移植到其他系统&＃xff08;int和long类型的大小不同&＃xff09;中会无法正常工作。在x和o前面可以使用l前缀&＃xff0c;%lx表示以十六进制格式打印long类型整数&＃xff0c;%lo表示以八进制格式打印long类型整数。注意&＃xff0c;虽然C允许使用大写或小写的常量后缀&＃xff0c;但是在转换说明中只能用小写。
C语言有多种printf()格式。对于short类型&＃xff0c;可以使用h前缀。%hd表示以十进制显示short类型的整数&＃xff0c;%ho表示以八进制显示short类型的整数。h和l前缀都可以和u一起使用&＃xff0c;用于表示无符号类型。例如&＃xff0c;%lu表示打印unsigned long类型的值。程序清单3.4演示了一些例子。对于支持long long类型的系统&＃xff0c;%lld和%llu分别表示有符号和无符号类型。第4章将详细介绍转换说明。
程序清单3.4 print2.c程序
/* print2.c--更多printf()的特性 */
#include
int main(void)
unsigned int un &＃61; 3000000000; /* int为32位和short为16位的系统 */
short end &＃61; 200;
long big &＃61; 65537;
long long verybig &＃61; 12345678908642;
printf("un &＃61; %u and not %d\\n", un, un);
printf("end &＃61; %hd and %d\\n", end, end);
printf("big &＃61; %ld and not %hd\\n", big, big);
printf("verybig&＃61; %lld and not %ld\\n", verybig, verybig);
return 0;
在特定的系统中输出如下&＃xff08;输出的结果可能不同&＃xff09;&＃xff1a;
un &＃61; 3000000000 and not -1294967296
end &＃61; 200 and 200
big &＃61; 65537 and not 1
verybig&＃61; 12345678908642 and not 1942899938
该例表明&＃xff0c;使用错误的转换说明会得到意想不到的结果。第1行输出&＃xff0c;对于无符号变量un&＃xff0c;使用%d会生成负值&＃xff01;其原因是&＃xff0c;无符号值3000000000和有符号值−129496296在系统内存中的内部表示完全相同&＃xff08;详见第15章&＃xff09;。因此&＃xff0c;如果告诉printf()该数是无符号数&＃xff0c;它打印一个值&＃xff1b;如果告诉它该数是有符号数&＃xff0c;它将打印另一个值。在待打印的值大于有符号值的最大值时&＃xff0c;会发生这种情况。对于较小的正数&＃xff08;如96&＃xff09;&＃xff0c;有符号和无符号类型的存储、显示都相同。
第2行输出&＃xff0c;对于short类型的变量end&＃xff0c;在printf()中无论指定以short类型&＃xff08;%hd&＃xff09;还是int类型&＃xff08;%d&＃xff09;打印&＃xff0c;打印出来的值都相同。这是因为在给函数传递参数时&＃xff0c;C编译器把short类型的值自动转换成int类型的值。你可能会提出疑问&＃xff1a;为什么要进行转换&＃xff1f;h修饰符有什么用&＃xff1f;第1个问题的答案是&＃xff0c;int类型被认为是计算机处理整数类型时最高效的类型。因此&＃xff0c;在short和int类型的大小不同的计算机中&＃xff0c;用int类型的参数传递速度更快。第2个问题的答案是&＃xff0c;使用h修饰符可以显示较大整数被截断成short类型值的情况。第 3 行输出就演示了这种情况。把 65537 以二进制格式写成一个 32 位数是
00000000000000010000000000000001。使用%hd&＃xff0c;printf()只会查看后16位&＃xff0c;所以显示的值是1。与此类似&＃xff0c;输出的最后一行先显示了verybig的完整值&＃xff0c;然后由于使用了%ld&＃xff0c;printf()只显示了储存在后32位的值。
本章前面介绍过&＃xff0c;程序员必须确保转换说明的数量和待打印值的数量相同。以上内容也提醒读者&＃xff0c;程序员还必须根据待打印值的类型使用正确的转换说明。
提示
匹配printf()说明符的类型
在使用printf()函数时&＃xff0c;切记检查每个待打印值都有对应的转换说明&＃xff0c;还要检查转换说明的类型是否与待打印值的类型相匹配。
char类型用于储存字符&＃xff08;如&＃xff0c;字母或标点符号&＃xff09;&＃xff0c;但是从技术层面看&＃xff0c;char是整数类型。因为char类型实际上储存的是整数而不是字符。计算机使用数字编码来处理字符&＃xff0c;即用特定的整数表示特定的字符。美国最常用的编码是ASCII编码&＃xff0c;本书也使用此编码。例如&＃xff0c;在ASCII码中&＃xff0c;整数65代表大写字母A。因此&＃xff0c;储存字母A实际上储存的是整数65&＃xff08;许多IBM的大型主机使用另一种编码——EBCDIC&＃xff0c;其原理相同。另外&＃xff0c;其他国家的计算机系统可能使用完全不同的编码&＃xff09;。
标准ASCII码的范围是0&＃xff5e;127&＃xff0c;只需7位二进制数即可表示。通常&＃xff0c;char类型被定义为8位的存储单元&＃xff0c;因此容纳标准ASCII码绰绰有余。许多其他系统&＃xff08;如IMB PC和苹果Macs&＃xff09;还提供扩展ASCII码&＃xff0c;也在8位的表示范围之内。一般而言&＃xff0c;C语言会保证char类型足够大&＃xff0c;以储存系统&＃xff08;实现C语言的系统&＃xff09;的基本字符集。
许多字符集都超过了127&＃xff0c;甚至多于255。例如&＃xff0c;日本汉字&＃xff08;kanji&＃xff09;字符集。商用的统一码&＃xff08;Unicode&＃xff09;创建了一个能表示世界范围内多种字符集的系统&＃xff0c;目前包含的字符已超过110000个。国际标准化组织&＃xff08;ISO&＃xff09;和国际电工技术委员会&＃xff08;IEC&＃xff09;为字符集开发了ISO/IEC 10646标准。统一码标准也与ISO/IEC 10646标准兼容。
C语言把1字节定义为char类型占用的位&＃xff08;bit&＃xff09;数&＃xff0c;因此无论是16位还是32位系统&＃xff0c;都可以使用char类型。
char类型变量的声明方式与其他类型变量的声明方式相同。下面是一些例子&＃xff1a;
char response;
char itable, latan;
以上声明创建了3个char类型的变量&＃xff1a;response、itable和latan。
如果要把一个字符常量初始化为字母A&＃xff0c;不必背下ASCII码&＃xff0c;用计算机语言很容易做到。通过以下初始化把字母A赋给grade即可&＃xff1a;
char grade &＃61; &＃39;A&＃39;;
在C语言中&＃xff0c;用单引号括起来的单个字符被称为字符常量&＃xff08;character constant&＃xff09;。编译器一发现&＃39;A&＃39;&＃xff0c;就会将其转换成相应的代码值。单引号必不可少。下面还有一些其他的例子&＃xff1a;
char broiled; /* 声明一个char类型的变量 */
broiled &＃61; &＃39;T&＃39;; /* 为其赋值&＃xff0c;正确 */
broiled &＃61; T; /* 错误&＃xff01;此时T是一个变量 */
broiled &＃61; "T"; /* 错误&＃xff01;此时"T"是一个字符串 */
如上所示&＃xff0c;如果省略单引号&＃xff0c;编译器认为T是一个变量名&＃xff1b;如果把T用双引号括起来&＃xff0c;编译器则认为"T"是一个字符串。字符串的内容将在第4章中介绍。
实际上&＃xff0c;字符是以数值形式储存的&＃xff0c;所以也可使用数字代码值来赋值&＃xff1a;
char grade &＃61; 65; /* 对于ASCII&＃xff0c;这样做没问题&＃xff0c;但这是一种不好的编程风格 */
在本例中&＃xff0c;虽然65是int类型&＃xff0c;但是它在char类型能表示的范围内&＃xff0c;所以将其赋值给grade没问题。由于65是字母A对应的ASCII码&＃xff0c;因此本例是把A赋给grade。注意&＃xff0c;能这样做的前提是系统使用ASCII码。其实&＃xff0c;用&＃39;A&＃39;代替65才是较为妥当的做法&＃xff0c;这样在任何系统中都不会出问题。因此&＃xff0c;最好使用字符常量&＃xff0c;而不是数字代码值。
奇怪的是&＃xff0c;C语言将字符常量视为int类型而非char类型。例如&＃xff0c;在int为32位、char为8位的ASCII系统中&＃xff0c;有下面的代码&＃xff1a;
char grade &＃61; &＃39;B&＃39;;
本来&＃39;B&＃39;对应的数值66储存在32位的存储单元中&＃xff0c;现在却可以储存在8位的存储单元中&＃xff08;grade&＃xff09;。利用字符常量的这种特性&＃xff0c;可以定义一个字符常量&＃39;FATE&＃39;&＃xff0c;即把4个独立的8位ASCII码储存在一个32位存储单元中。如果把这样的字符常量赋给char类型变量grade&＃xff0c;只有最后8位有效。因此&＃xff0c;grade的值是&＃39;E&＃39;。
单引号只适用于字符、数字和标点符号&＃xff0c;浏览ASCII表会发现&＃xff0c;有些ASCII字符打印不出来。例如&＃xff0c;一些代表行为的字符&＃xff08;如&＃xff0c;退格、换行、终端响铃或蜂鸣&＃xff09;。C语言提供了3种方法表示这些字符。
第1种方法前面介绍过——使用ASCII码。例如&＃xff0c;蜂鸣字符的ASCII值是7&＃xff0c;因此可以这样写&＃xff1a;
char beep &＃61; 7;
第2种方法是&＃xff0c;使用特殊的符号序列表示一些特殊的字符。这些符号序列叫作转义序列&＃xff08;escape sequence&＃xff09;。表3.2列出了转义序列及其含义。
把转义序列赋给字符变量时&＃xff0c;必须用单引号把转义序列括起来。例如&＃xff0c;假设有下面一行代码&＃xff1a;
char nerf &＃61; &＃39;\\n&＃39;;
稍后打印变量nerf的效果是&＃xff0c;在打印机或屏幕上另起一行。
表3.2 转义序列
| 转义序列 | 含义 |
| \\a | 警报&＃xff08;ANSI C&＃xff09; |
| \\b | 退格 |
| \\f | 换页 |
| \\n | 换行 |
| \\r | 回车 |
| \\t | 水平制表符 |
| \\v | 垂直制表符 |
| \\\\ | 反斜杠&＃xff08;\\&＃xff09; |
| \\&＃39; | 单引号 |
| \\" | 双引号 |
| \\? | 问号 |
| \\0oo | 八进制值&＃xff08;oo必须是有效的八进制数&＃xff0c;即每个o可表示0&＃xff5e;7中的一个数&＃xff09; |
| \\xhh | 十六进制值&＃xff08;hh必须是有效的十六进制数&＃xff0c;即每个h可表示0&＃xff5e;f中的一个数&＃xff09; |
现在&＃xff0c;我们来仔细分析一下转义序列。使用C90新增的警报字符&＃xff08;\\a&＃xff09;是否能产生听到或看到的警报&＃xff0c;取决于计算机的硬件&＃xff0c;蜂鸣是最常见的警报&＃xff08;在一些系统中&＃xff0c;警报字符不起作用&＃xff09;。C标准规定警报字符不得改变活跃位置。标准中的活跃位置&＃xff08;active position&＃xff09;指的是显示设备&＃xff08;屏幕、电传打字机、打印机等&＃xff09;中下一个字符将出现的位置。简而言之&＃xff0c;平时常说的屏幕光标位置就是活跃位置。在程序中把警报字符输出在屏幕上的效果是&＃xff0c;发出一声蜂鸣&＃xff0c;但不会移动屏幕光标。
接下来的转义字符\\b、\\f、\\n、\\r、\\t和\\v是常用的输出设备控制字符。了解它们最好的方式是查看它们对活跃位置的影响。换页符&＃xff08;\\f&＃xff09;把活跃位置移至下一页的开始处&＃xff1b;换行符&＃xff08;\\n&＃xff09;把活跃位置移至下一行的开始处&＃xff1b;回车符&＃xff08;\\r&＃xff09;把活跃位置移动到当前行的开始处&＃xff1b;水平制表符&＃xff08;\\t&＃xff09;将活跃位置移至下一个水平制表点&＃xff08;通常是第1个、第9个、第17个、第25个等字符位置&＃xff09;&＃xff1b;垂直制表符&＃xff08;\\v&＃xff09;把活跃位置移至下一个垂直制表点。
这些转义序列字符不一定在所有的显示设备上都起作用。例如&＃xff0c;换页符和垂直制表符在PC屏幕上会生成奇怪的符号&＃xff0c;光标并不会移动。只有将其输出到打印机上时才会产生前面描述的效果。
接下来的3个转义序列&＃xff08;\\\\、\\&＃39;、\\"&＃xff09;用于打印\\、&＃39;、"字符&＃xff08;由于这些字符用于定义字符常量&＃xff0c;是printf()函数的一部分&＃xff0c;若直接使用它们会造成混乱&＃xff09;。如果打印下面一行内容&＃xff1a;
Gramps sez, "a \\ is a backslash."
应这样编写代码&＃xff1a;
printf("Gramps sez, \\"a \\\\ is a backslash.\\"\\n");
表3.2中的最后两个转义序列&＃xff08;\\0oo和\\xhh&＃xff09;是ASCII码的特殊表示。如果要用八进制ASCII码表示一个字符&＃xff0c;可以在编码值前面加一个反斜杠&＃xff08;\\&＃xff09;并用单引号括起来。例如&＃xff0c;如果编译器不识别警报字符&＃xff08;\\a&＃xff09;&＃xff0c;可以使用ASCII码来代替&＃xff1a;
beep &＃61; &＃39;\\007&＃39;;
可以省略前面的0&＃xff0c;&＃39;\\07&＃39;甚至&＃39;\\7&＃39;都可以。即使没有前缀0&＃xff0c;编译器在处理这种写法时&＃xff0c;仍会解释为八进制。
从C90开始&＃xff0c;不仅可以用十进制、八进制形式表示字符常量&＃xff0c;C语言还提供了第3种选择——用十六进制形式表示字符常量&＃xff0c;即反斜杠后面跟一个x或X&＃xff0c;再加上1&＃xff5e;3位十六进制数字。例如&＃xff0c;Ctrl&＃43;P字符的ASCII十六进制码是10&＃xff08;相当于十进制的16&＃xff09;&＃xff0c;可表示为&＃39;\\x10&＃39;或&＃39;\\x010&＃39;。图3.5列出了一些整数类型的不同进制形式。
图3.5 int系列类型的常量写法示例
使用ASCII码时&＃xff0c;注意数字和数字字符的区别。例如&＃xff0c;字符4对应的ASCII码是52。&＃39;4&＃39;表示字符4&＃xff0c;而不是数值4。
关于转义序列&＃xff0c;读者可能有下面3个问题。
printf()函数用%c指明待打印的字符。前面介绍过&＃xff0c;一个字符变量实际上被储存为1字节的整数值。因此&＃xff0c;如果用%d转换说明打印char类型变量的值&＃xff0c;打印的是一个整数。而%c转换说明告诉printf()打印该整数值对应的字符。程序清单3.5演示了打印char类型变量的两种方式。
程序清单3.5 charcode.c程序
/* charcode.c-显示字符的代码编号 */
#include
int main(void)
char ch;
printf("Please enter a character.\\n");
scanf("%c", &ch); /* 用户输入字符 */
printf("The code for %c is %d.\\n", ch, ch);
return 0;
运行该程序后&＃xff0c;输出示例如下&＃xff1a;
Please enter a character.
C
The code for C is 67.
运行该程序时&＃xff0c;在输入字母后不要忘记按下Enter或Return键。随后&＃xff0c;scanf()函数会读取用户输入的字符&＃xff0c;&符号表示把输入的字符赋给变量ch。接着&＃xff0c;printf()函数打印ch的值两次&＃xff0c;第1次打印一个字符&＃xff08;对应代码中的%c&＃xff09;&＃xff0c;第2次打印一个十进制整数值&＃xff08;对应代码中的%d&＃xff09;。注意&＃xff0c;printf()函数中的转换说明决定了数据的显示方式&＃xff0c;而不是数据的储存方式&＃xff08;见图3.6&＃xff09;。
图3.6 数据显示和数据存储
有些C编译器把char实现为有符号类型&＃xff0c;这意味着char可表示的范围是-128&＃xff5e;127。而有些C编译器把char实现为无符号类型&＃xff0c;那么char可表示的范围是0&＃xff5e;255。请查阅相应的编译器手册&＃xff0c;确定正在使用的编译器如何实现char类型。或者&＃xff0c;可以查阅limits.h头文件。下一章将详细介绍头文件的内容。
根据C90标准&＃xff0c;C语言允许在关键字char前面使用signed或unsigned。这样&＃xff0c;无论编译器默认char是什么类型&＃xff0c;signed char表示有符号类型&＃xff0c;而unsigned char表示无符号类型。这在用char类型处理小整数时很有用。如果只用char处理字符&＃xff0c;那么char前面无需使用任何修饰符。
C99标准添加了_Bool类型&＃xff0c;用于表示布尔值&＃xff0c;即逻辑值true和false。因为C语言用值1表示true&＃xff0c;值0表示false&＃xff0c;所以_Bool类型实际上也是一种整数类型。但原则上它仅占用1位存储空间&＃xff0c;因为对0和1而言&＃xff0c;1位的存储空间足够了。
程序通过布尔值可选择执行哪部分代码。我们将在第6章和第7章中详述相关内容。
C语言提供了许多有用的整数类型。但是&＃xff0c;某些类型名在不同系统中的功能不一样。C99新增了两个头文件stdint.h和inttypes.h&＃xff0c;以确保C语言的类型在各系统中的功能相同。
C语言为现有类型创建了更多类型名。这些新的类型名定义在stdint.h头文件中。例如&＃xff0c;int32_t表示32位的有符号整数类型。在使用32位int的系统中&＃xff0c;头文件会把int32_t作为int的别名。不同的系统也可以定义相同的类型名。例如&＃xff0c;int为16位、long为32位的系统会把int32_t作为long的别名。然后&＃xff0c;使用int32_t类型编写程序&＃xff0c;并包含stdint.h头文件时&＃xff0c;编译器会把int或long替换成与当前系统匹配的类型。
上面讨论的类型别名是精确宽度整数类型&＃xff08;exact-width integer type&＃xff09;的示例。int32_t表示整数类型的宽度正好是32位。但是&＃xff0c;计算机的底层系统可能不支持。因此&＃xff0c;精确宽度整数类型是可选项。
如果系统不支持精确宽度整数类型怎么办&＃xff1f;C99和C11提供了第2类别名集合。一些类型名保证所表示的类型一定是至少有指定宽度的最小整数类型。这组类型集合被称为最小宽度类型&＃xff08;minimum width type&＃xff09;。例如&＃xff0c;int_least8_t是可容纳8位有符号整数值的类型中宽度最小的类型的一个别名。如果某系统的最小整数类型是16位&＃xff0c;可能不会定义int8_t类型。尽管如此&＃xff0c;该系统仍可使用int_least8_t类型&＃xff0c;但可能把该类型实现为16位的整数类型。
当然&＃xff0c;一些程序员更关心速度而非空间。为此&＃xff0c;C99和C11定义了一组可使计算达到最快的类型集合。这组类型集合被称为最快最小宽度类型&＃xff08;fastst minimum width type&＃xff09;。例如&＃xff0c;int_fast8_t被定义为系统中对8位有符号值而言运算最快的整数类型的别名。
另外&＃xff0c;有些程序员需要系统的最大整数类型。为此&＃xff0c;C99定义了最大的有符号整数类型intmax_t&＃xff0c;可储存任何有效的有符号整数值。类似地&＃xff0c;uintmax_t表示最大的无符号整数类型。顺带一提&＃xff0c;这些类型有可能比long long和unsigned long类型更大&＃xff0c;因为C编译器除了实现标准规定的类型以外&＃xff0c;还可利用C语言实现其他类型。例如&＃xff0c;一些编译器在标准引入long long类型之前&＃xff0c;已提前实现了该类型。
C99和C11不仅提供可移植的类型名&＃xff0c;还提供相应的输入和输出。例如&＃xff0c;printf()打印特定类型时要求与相应的转换说明匹配。如果要打印int32_t类型的值&＃xff0c;有些定义使用%d&＃xff0c;而有些定义使用%ld&＃xff0c;怎么办&＃xff1f;C标准针对这一情况&＃xff0c;提供了一些字符串宏&＃xff08;第4章中详细介绍&＃xff09;来显示可移植类型。例如&＃xff0c;inttypes.h头文件中定义了PRId32字符串宏&＃xff0c;代表打印32位有符号值的合适转换说明&＃xff08;如d或l&＃xff09;。程序清单3.6演示了一种可移植类型和相应转换说明的用法。
程序清单3.6 altnames.c程序
/* altnames.c -- 可移植整数类型名 */
#include
#include
int main(void)
int32_t me32; // me32是一个32位有符号整型变量
me32 &＃61; 45933945;
printf("First, assume int32_t is int: ");
printf("me32 &＃61; %d\\n", me32);
printf("Next, let&＃39;s not make any assumptions.\\n");
printf("Instead, use a \\"macro\\" from inttypes.h: ");
printf("me32 &＃61; %" "d" "\\n", me32);
return 0;
该程序最后一个printf()中&＃xff0c;参数PRId32被定义在inttypes.h中的"d"替换&＃xff0c;因而这条语句等价于&＃xff1a;
printf(“me32 &＃61; %d\\n”, me32);
在C语言中&＃xff0c;可以把多个连续的字符串组合成一个字符串&＃xff0c;所以这条语句又等价于&＃xff1a;
printf("me32 &＃61; %d\\n", me32);
下面是该程序的输出&＃xff0c;注意&＃xff0c;程序中使用了\\"转义序列来显示双引号&＃xff1a;
First, assume int32_t is int: me32 &＃61; 45933945
Next, let&＃39;s not make any assumptions.
Instead, use a "macro" from inttypes.h: me32 &＃61; 45933945
篇幅有限&＃xff0c;无法介绍扩展的所有整数类型。本节主要是为了让读者知道&＃xff0c;在需要时可进行这种级别的类型控制。附录B中的参考资料VI“扩展的整数类型”介绍了完整的inttypes.h和stdint.h头文件。
注意
对C99/C11的支持
C语言发展至今&＃xff0c;虽然ISO已发布了C11标准&＃xff0c;但是编译器供应商对C99的实现程度却各不相同。在本书第6版的编写过程中&＃xff0c;一些编译器仍未实现inttypes.h头文件及其相关功能。
各种整数类型对大多数软件开发项目而言够用了。然而&＃xff0c;面向金融和数学的程序经常使用浮点数。C语言中的浮点类型有float、double和long double类型。它们与FORTRAN和Pascal中的real类型一致。前面提到过&＃xff0c;浮点类型能表示包括小数在内更大范围的数。浮点数的表示类似于科学记数法&＃xff08;即用小数乘以10的幂来表示数字&＃xff09;。该记数系统常用于表示非常大或非常小的数。表3.3列出了一些示例。
表3.3 记数法示例
| 数字 | 科学记数法 | 指数记数法 |
| 1000000000 | 1.0×109 | 1.0e9 |
| 123000 | 1.23×105 | 1.23e5 |
| 322.56 | 3.2256×102 | 3.2256e2 |
| 0.000056 | 5.6×10-5 | 5.6e-5 |
第1列是一般记数法&＃xff1b;第2列是科学记数法&＃xff1b;第3列是指数记数法&＃xff08;或称为e记数法&＃xff09;&＃xff0c;这是科学记数法在计算机中的写法&＃xff0c;e后面的数字代表10的指数。图3.7演示了更多的浮点数写法。
图3.7 更多浮点数写法示例
C标准规定&＃xff0c;float类型必须至少能表示6位有效数字&＃xff0c;且取值范围至少是10-37&＃xff5e;10&＃43;37。前一项规定指float类型必须能够表示33.333333的前6位数字&＃xff0c;而不是精确到小数点后6位数字。后一项规定用于方便地表示诸如太阳质量&＃xff08;2.0e30千克&＃xff09;、一个质子的电荷量&＃xff08;1.6e-19库仑&＃xff09;或国家债务之类的数字。通常&＃xff0c;系统储存一个浮点数要占用32位。其中8位用于表示指数的值和符号&＃xff0c;剩下24位用于表示非指数部分&＃xff08;也叫作尾数或有效数&＃xff09;及其符号。
C语言提供的另一种浮点类型是double&＃xff08;意为双精度&＃xff09;。double类型和float类型的最小取值范围相同&＃xff0c;但至少必须能表示10位有效数字。一般情况下&＃xff0c;double占用64位而不是32位。一些系统将多出的32位全部用来表示非指数部分&＃xff0c;这不仅增加了有效数字的位数&＃xff08;即提高了精度&＃xff09;&＃xff0c;而且还减少了舍入误差。另一些系统把其中的一些位分配给指数部分&＃xff0c;以容纳更大的指数&＃xff0c;从而增加了可表示数的范围。无论哪种方法&＃xff0c;double类型的值至少有13位有效数字&＃xff0c;超过了标准的最低位数规定。
C语言的第3种浮点类型是long double&＃xff0c;以满足比double类型更高的精度要求。不过&＃xff0c;C只保证long double类型至少与double类型的精度相同。
浮点型变量的声明和初始化方式与整型变量相同&＃xff0c;下面是一些例子&＃xff1a;
float noah, jonah;
double trouble;
float planck &＃61; 6.63e-34;
long double gnp;
2&＃xff0e;浮点型常量
在代码中&＃xff0c;可以用多种形式书写浮点型常量。浮点型常量的基本形式是&＃xff1a;有符号的数字&＃xff08;包括小数点&＃xff09;&＃xff0c;后面紧跟e或E&＃xff0c;最后是一个有符号数表示10的指数。下面是两个有效的浮点型常量&＃xff1a;
-1.56E&＃43;12
2.87e-3
正号可以省略。可以没有小数点&＃xff08;如&＃xff0c;2E5&＃xff09;或指数部分&＃xff08;如&＃xff0c;19.28&＃xff09;&＃xff0c;但是不能同时省略两者。可以省略小数部分&＃xff08;如&＃xff0c;3.E16&＃xff09;或整数部分&＃xff08;如&＃xff0c;.45E-6&＃xff09;&＃xff0c;但是不能同时省略两者。下面是更多的有效浮点型常量示例&＃xff1a;
3.14159
.2
4e16
.8E-5
100&＃xff0e;
不要在浮点型常量中间加空格&＃xff1a;1.56 E&＃43;12&＃xff08;错误&＃xff01;&＃xff09;
默认情况下&＃xff0c;编译器假定浮点型常量是double类型的精度。例如&＃xff0c;假设some是float类型的变量&＃xff0c;编写下面的语句&＃xff1a;
some &＃61; 4.0 * 2.0;
通常&＃xff0c;4.0和2.0被储存为64位的double类型&＃xff0c;使用双精度进行乘法运算&＃xff0c;然后将乘积截断成float类型的宽度。这样做虽然计算精度更高&＃xff0c;但是会减慢程序的运行速度。
在浮点数后面加上f或F后缀可覆盖默认设置&＃xff0c;编译器会将浮点型常量看作float类型&＃xff0c;如2.3f和9.11E9F。使用l或L后缀使得数字成为long double类型&＃xff0c;如54.3l和4.32L。注意&＃xff0c;建议使用L后缀&＃xff0c;因为字母l和数字1很容易混淆。没有后缀的浮点型常量是double类型。
C99标准添加了一种新的浮点型常量格式——用十六进制表示浮点型常量&＃xff0c;即在十六进制数前加上十六进制前缀&＃xff08;0x或0X&＃xff09;&＃xff0c;用p和P分别代替e和E&＃xff0c;用2的幂代替10的幂&＃xff08;即&＃xff0c;p计数法&＃xff09;。如下所示&＃xff1a;
0xa.1fp10
十六进制a等于十进制10&＃xff0c;.1f是1/16加上15/256&＃xff08;十六进制f等于十进制15&＃xff09;&＃xff0c;p10是210或1024。0xa.1fp10表示的值是(10 &＃43; 1/16 &＃43; 15/256)×1024&＃xff08;即&＃xff0c;十进制10364.0&＃xff09;。
注意&＃xff0c;并非所有的编译器都支持C99的这一特性。
printf()函数使用%f转换说明打印十进制记数法的float和double类型浮点数&＃xff0c;用%e打印指数记数法的浮点数。如果系统支持十六进制格式的浮点数&＃xff0c;可用a和A分别代替e和E。打印long double类型要使用%Lf、%Le或%La转换说明。给那些未在函数原型中显式说明参数类型的函数&＃xff08;如&＃xff0c;printf()&＃xff09;传递参数时&＃xff0c;C编译器会把float类型的值自动转换成double类型。程序清单3.7演示了这些特性。
程序清单3.7 showf_pt.c程序
/* showf_pt.c -- 以两种方式显示float类型的值 */
#include
int main(void)
float aboat &＃61; 32000.0;
double abet &＃61; 2.14e9;
long double dip &＃61; 5.32e-5;
printf("%f can be written %e\\n", aboat, aboat);
// 下一行要求编译器支持C99或其中的相关特性
printf("And it&＃39;s %a in hexadecimal, powers of 2 notation\\n", aboat);
printf("%f can be written %e\\n", abet, abet);
printf("%Lf can be written %Le\\n", dip, dip);
return 0;
该程序的输出如下&＃xff0c;前提是编译器支持C99/C11&＃xff1a;
32000.000000 can be written 3.200000e&＃43;04
And it&＃39;s 0x1.f4p&＃43;14 in hexadecimal, powers of 2 notation
2140000000.000000 can be written 2.140000e&＃43;09
0.000053 can be written 5.320000e-05
该程序示例演示了默认的输出效果。下一章将介绍如何通过设置字段宽度和小数位数来控制输出格式。
假设系统的最大float类型值是3.4E38&＃xff0c;编写如下代码&＃xff1a;
float toobig &＃61; 3.4E38 * 100.0f;
printf("%e\\n", toobig);
会发生什么&＃xff1f;这是一个上溢&＃xff08;overflow&＃xff09;的示例。当计算导致数字过大&＃xff0c;超过当前类型能表达的范围时&＃xff0c;就会发生上溢。这种行为在过去是未定义的&＃xff0c;不过现在C语言规定&＃xff0c;在这种情况下会给toobig赋一个表示无穷大的特定值&＃xff0c;而且printf()显示该值为inf或infinity&＃xff08;或者具有无穷含义的其他内容&＃xff09;。
当对一个很小的数做除法时&＃xff0c;情况更为复杂。回忆一下&＃xff0c;float类型的数以指数和尾数部分来储存。存在这样一个数&＃xff0c;它的指数部分是最小值&＃xff0c;即由全部可用位表示的最小尾数值。该数字是float类型能用全部精度表示的最小数字。现在把它除以2。通常&＃xff0c;这个操作会减小指数部分&＃xff0c;但是假设的情况中&＃xff0c;指数已经是最小值了。所以计算机只好把尾数部分的位向右移&＃xff0c;空出第1个二进制位&＃xff0c;并丢弃最后一个二进制数。以十进制为例&＃xff0c;把一个有4位有效数字的数&＃xff08;如&＃xff0c;0.1234E-10&＃xff09;除以10&＃xff0c;得到的结果是0.0123E-10。虽然得到了结果&＃xff0c;但是在计算过程中却损失了原末尾有效位上的数字。这种情况叫作下溢&＃xff08;underflow&＃xff09;。C语言把损失了类型全精度的浮点值称为低于正常的&＃xff08;subnormal&＃xff09;浮点值。因此&＃xff0c;把最小的正浮点数除以2将得到一个低于正常的值。如果除以一个非常大的值&＃xff0c;会导致所有的位都为0。现在&＃xff0c;C库已提供了用于检查计算是否会产生低于正常值的函数。
还有另一个特殊的浮点值NaN&＃xff08;not a number的缩写&＃xff09;。例如&＃xff0c;给asin()函数传递一个值&＃xff0c;该函数将返回一个角度&＃xff0c;该角度的正弦就是传入函数的值。但是正弦值不能大于1&＃xff0c;因此&＃xff0c;如果传入的参数大于1&＃xff0c;该函数的行为是未定义的。在这种情况下&＃xff0c;该函数将返回NaN值&＃xff0c;printf()函数可将其显示为nan、NaN或其他类似的内容。
浮点数舍入错误
给定一个数&＃xff0c;加上1&＃xff0c;再减去原来给定的数&＃xff0c;结果是多少&＃xff1f;你一定认为是1。但是&＃xff0c;下面的浮点运算给出了不同的答案&＃xff1a;
/* floaterr.c--演示舍入错误 */ #include
int main(void) float a,b; b &＃61; 2.0e20 &＃43; 1.0; a &＃61; b - 2.0e20; printf("%f \\n", a); return 0;
该程序的输出如下&＃xff1a;
0.000000 ←Linux系统下的老式gcc -13584010575872.000000 ←Turbo C 1.5 4008175468544.000000 ←XCode 4.5、Visual Studio 2012、当前版本的gcc
得出这些奇怪答案的原因是&＃xff0c;计算机缺少足够的小数位来完成正确的运算。2.0e20是2后面有20个0。如果把该数加1&＃xff0c;那么发生变化的是第21位。要正确运算&＃xff0c;程序至少要储存21位数字。而float类型的数字通常只能储存按指数比例缩小或放大的6或7位有效数字。在这种情况下&＃xff0c;计算结果一定是错误的。另一方面&＃xff0c;如果把2.0e20改成2.0e4&＃xff0c;计算结果就没问题。因为2.0e4加1只需改变第5位上的数字&＃xff0c;float类型的精度足够进行这样的计算。
浮点数表示法
上一个方框中列出了由于计算机使用的系统不同&＃xff0c;一个程序有不同的输出。原因是&＃xff0c;根据前面介绍的知识&＃xff0c;实现浮点数表示法的方法有多种。为了尽可能地统一实现&＃xff0c;电子和电气工程师协会&＃xff08;IEEE&＃xff09;为浮点数计算和表示法开发了一套标准。现在&＃xff0c;许多硬件浮点单元都采用该标准。2011年&＃xff0c;该标准被ISO/IEC/IEEE 60559:2011标准收录。该标准作为C99和C11的可选项&＃xff0c;符合硬件要求的平台可开启。floaterr.c程序的第3个输出示例即是支持该浮点标准的系统显示的结果。支持C标准的编译器还包含捕获异常问题的工具。详见附录B.5&＃xff0c;参考资料V。
许多科学和工程计算都要用到复数和虚数。C99标准支持复数类型和虚数类型&＃xff0c;但是有所保留。一些独立实现&＃xff0c;如嵌入式处理器的实现&＃xff0c;就不需要使用复数和虚数&＃xff08;VCR芯片就不需要复数&＃xff09;。一般而言&＃xff0c;虚数类型都是可选项。C11标准把整个复数软件包都作为可选项。
简而言之&＃xff0c;C语言有3种复数类型&＃xff1a;float _Complex、double _Complex和long double _Complex。例如&＃xff0c;float _Complex类型的变量应包含两个float类型的值&＃xff0c;分别表示复数的实部和虚部。类似地&＃xff0c;C语言的3种虚数类型是float _Imaginary、double _Imaginary和long double _Imaginary。
如果包含complex.h头文件&＃xff0c;便可用complex代替_Complex&＃xff0c;用imaginary代替_Imaginary&＃xff0c;还可以用I代替-1的平方根。
为何C标准不直接用complex作为关键字来代替_Complex&＃xff0c;而要添加一个头文件&＃xff08;该头文件中把complex定义为_Complex&＃xff09;&＃xff1f;因为标准委员会考虑到&＃xff0c;如果使用新的关键字&＃xff0c;会导致以该关键字作为标识符的现有代码全部失效。例如&＃xff0c;之前的C99&＃xff0c;许多程序员已经使用struct complex定义一个结构来表示复数或者心理学程序中的心理状况&＃xff08;关键字struct用于定义能储存多个值的结构&＃xff0c;详见第14章&＃xff09;。让complex成为关键字会导致之前的这些代码出现语法错误。但是&＃xff0c;使用struct _Complex的人很少&＃xff0c;特别是标准使用首字母是下划线的标识符作为预留字以后。因此&＃xff0c;标准委员会选定_Complex作为关键字&＃xff0c;在不用考虑名称冲突的情况下可选择使用complex。
现在已经介绍完C语言的所有基本数据类型。有些人认为这些类型实在太多了&＃xff0c;但有些人觉得还不够用。注意&＃xff0c;虽然C语言没有字符串类型&＃xff0c;但也能很好地处理字符串。第4章将详细介绍相关内容。
C语言还有一些从基本类型衍生的其他类型&＃xff0c;包括数组、指针、结构和联合。尽管后面章节中会详细介绍这些类型&＃xff0c;但是本章的程序示例中已经用到了指针〔指针&＃xff08;pointer&＃xff09;指向变量或其他数据对象位置〕。例如&＃xff0c;在scanf()函数中用到的前缀&&＃xff0c;便创建了一个指针&＃xff0c;告诉scanf()把数据放在何处。
小结&＃xff1a;基本数据类型
关键字&＃xff1a;
基本数据类型由11个关键字组成&＃xff1a;int、long、short、unsigned、char、float、double、signed、_Bool、_Complex和_Imaginary。
有符号整型&＃xff1a;
有符号整型可用于表示正整数和负整数。
int ——系统给定的基本整数类型。C语言规定int类型不小于16位。short或short int ——最大的short类型整数小于或等于最大的int类型整数。C语言规定short类型至少占16位。long或long int ——该类型可表示的整数大于或等于最大的int类型整数。C语言规定long类型至少占32位。long long或long long int ——该类型可表示的整数大于或等于最大的long类型整数。long long类型至少占64位。
一般而言&＃xff0c;long类型占用的内存比short类型大&＃xff0c;int类型的宽度要么和long类型相同&＃xff0c;要么和short类型相同。例如&＃xff0c;旧DOS系统的PC提供16位的short和int&＃xff0c;以及32位的long&＃xff1b;Windows 95系统提供16位的short以及32位的int和long。
无符号整型&＃xff1a;
无符号整型只能用于表示零和正整数&＃xff0c;因此无符号整型可表示的正整数比有符号整型的大。在整型类型前加上关键字unsigned表明该类型是无符号整型&＃xff1a;unsigned int、unsigned long、unsigned short。单独的unsigned相当于unsigned int。
字符类型&＃xff1a;
可打印出来的符号&＃xff08;如A、&和&＃43;&＃xff09;都是字符。根据定义&＃xff0c;char类型表示一个字符要占用1字节内存。出于历史原因&＃xff0c;1字节通常是8位&＃xff0c;但是如果要表示基本字符集&＃xff0c;也可以是16位或更大。
char ——字符类型的关键字。有些编译器使用有符号的char&＃xff0c;而有些则使用无符号的char。在需要时&＃xff0c;可在char前面加上关键字signed或unsigned来指明具体使用哪一种类型。
布尔类型&＃xff1a;
布尔值表示true和false。C语言用1表示true&＃xff0c;0表示false。
_Bool ——布尔类型的关键字。布尔类型是无符号int类型&＃xff0c;所占用的空间只要能储存0或1即可。
实浮点类型&＃xff1a;
实浮点类型可表示正浮点数和负浮点数。
float ——系统的基本浮点类型&＃xff0c;可精确表示至少6位有效数字。double ——储存浮点数的范围&＃xff08;可能&＃xff09;更大&＃xff0c;能表示比float类型更多的有效数字&＃xff08;至少10位&＃xff0c;通常会更多&＃xff09;和更大的指数。long double ——储存浮点数的范围&＃xff08;可能&＃xff09;比double更大&＃xff0c;能表示比double更多的有效数字和更大的指数。
复数和虚数浮点数&＃xff1a;
虚数类型是可选的类型。复数的实部和虚部类型都基于实浮点类型来构成&＃xff1a;
float _Complexdouble _Complexlong double _Complexfloat _Imaginarydouble _Imaginarylong double _Imaginary
小结&＃xff1a;如何声明简单变量
1&＃xff0e;选择需要的类型。
2&＃xff0e;使用有效的字符给变量起一个变量名。
3&＃xff0e;按以下格式进行声明&＃xff1a;
类型说明符 变量名;
类型说明符由一个或多个关键字组成。下面是一些示例&＃xff1a;
int erest; unsigned short cash;
4&＃xff0e;可以同时声明相同类型的多个变量&＃xff0c;用逗号分隔各变量名&＃xff0c;如下所示&＃xff1a;
char ch, init, ans;
5&＃xff0e;在声明的同时还可以初始化变量&＃xff1a;
float mass &＃61; 6.0E24;
如何知道当前系统的指定类型的大小是多少&＃xff1f;运行程序清单3.8&＃xff0c;会列出当前系统的各类型的大小。
程序清单3.8 typesize.c程序
/* typesize.c -- 打印类型大小 */
#include
int main(void)
/* C99为类型大小提供%zd转换说明 */
printf("Type int has a size of %zd bytes.\\n", sizeof(int));
printf("Type char has a size of %zd bytes.\\n", sizeof(char));
printf("Type long has a size of %zd bytes.\\n", sizeof(long));
printf("Type long long has a size of %zd bytes.\\n",
sizeof(long long));
printf("Type double has a size of %zd bytes.\\n",
sizeof(double));
printf("Type long double has a size of %zd bytes.\\n",
sizeof(long double));
return 0;
sizeof是C语言的内置运算符&＃xff0c;以字节为单位给出指定类型的大小。C99和C11提供%zd转换说明匹配sizeof的返回类型[2]。一些不支持C99和C11的编译器可用%u或%lu代替%zd。
该程序的输出如下&＃xff1a;
Type int has a size of 4 bytes.
Type char has a size of 1 bytes.
Type long has a size of 8 bytes.
Type long long has a size of 8 bytes.
Type double has a size of 8 bytes.
Type long double has a size of 16 bytes.
该程序列出了6种类型的大小&＃xff0c;你也可以把程序中的类型更换成感兴趣的其他类型。注意&＃xff0c;因为C语言定义了char类型是1字节&＃xff0c;所以char类型的大小一定是1字节。而在char类型为16位、double类型为64位的系统中&＃xff0c;sizeof给出的double是4字节。在limits.h和float.h头文件中有类型限制的相关信息&＃xff08;下一章将详细介绍这两个头文件&＃xff09;。
顺带一提&＃xff0c;注意该程序最后几行printf()语句都被分为两行&＃xff0c;只要不在引号内部或一个单词中间断行&＃xff0c;就可以这样写。
本文摘自《C Primer Plus&＃xff08;第6版&＃xff09;》中文版
本书详细讲解了C语言的基本概念和编程技巧。
全书共17章。第1章、第2章介绍了C语言编程的预备知识。第3章&＃xff5e;第15章详细讲解了C语言的相关知识&＃xff0c;包括数据类型、格式化输入/输出、运算符、表达式、语句、循环、字符输入和输出、函数、数组和指针、字符和字符串函数、内存管理、文件输入输出、结构、位操作等。第16章、第17章介绍C预处理器、C库和高级数据表示。本书以完整的程序为例&＃xff0c;讲解C语言的知识要点和注意事项。每章末尾设计了大量复习题和编程练习&＃xff0c;帮助读者巩固所学知识和提高实际编程能力。附录给出了各章复习题的参考答案和丰富的参考资料。
本书可作为C语言的教材&＃xff0c;适用于需要系统学习C语言的初学者&＃xff0c;也适用于巩固C语言知识或希望进一步提高编程技术的程序员。
京公网安备 11010802041100号 | 京ICP备19059560号-4 | PHP1.CN 第一PHP社区 版权所有